package com.hlw.manage.core.handler;

import com.zaxxer.hikari.HikariDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;

import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.*;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.StringUtils;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author mqz
 * @description 数据源注册配置
 * @since 2020/4/27
 */
@Configuration
public class DataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    private static final Logger logger = LoggerFactory.getLogger(DataSourceRegister.class);

    /**配置上下文（也可以理解为配置文件的获取工具）*/
    private Environment evn;

    /**别名*/
    private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();

    /**由于部分数据源配置不同，所以在此处添加别名，避免切换数据源出现某些参数无法注入的情况*/
    static {
        aliases.addAliases("url", new String[]{"jdbc-url"});
        aliases.addAliases("username", new String[]{"user"});
    }

    /**存储我们注册的数据源*/
    private Map<String, DataSource> customDataSources = new HashMap<String, DataSource>();

    /**参数绑定工具 springboot2.0新推出 - 巨坑-1.15版本的spring-boot和当前版本使用的绑定数据源使用不一样，参考https://github.com/DemoMeng?tab=repositories*/
    private Binder binder;

    /**ImportBeanDefinitionRegistrar接口的实现方法，通过该方法可以按照自己的方式注册bean*/
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        /** 获取所有数据源配置*/
        Map config, defaultDataSourceProperties;
        defaultDataSourceProperties = binder.bind("spring.datasource.master", Map.class).get();
        /**获取数据源类型*/
        String typeStr = evn.getProperty("spring.datasource.master.type");
        /** 获取数据源类型*/
        Class<? extends DataSource> clazz = getDataSourceType(typeStr);
        /** 绑定默认数据源参数 也就是主数据源*/
        DataSource consumerDatasource, defaultDatasource = bind(clazz, defaultDataSourceProperties);
        DataSourceHandler.dataSourceIds.add("master");
        logger.info("注册默认数据源成功");
        /** 获取其他数据源配置*/
        List<Map> configs = binder.bind("spring.datasource.cluster", Bindable.listOf(Map.class)).get();
        /** 遍历从数据源*/
        for (int i = 0; i < configs.size(); i++) {
            config = configs.get(i);
            clazz = getDataSourceType((String) config.get("type"));
            defaultDataSourceProperties = config;
            /**绑定参数*/
            consumerDatasource = bind(clazz, defaultDataSourceProperties);
            /** 获取数据源的key，以便通过该key可以定位到数据源*/
            String key = config.get("key").toString();
            customDataSources.put(key, consumerDatasource);
            /** 数据源上下文，用于管理数据源与记录已经注册的数据源key*/
            DataSourceHandler.dataSourceIds.add(key);
            logger.info("注册数据源{}成功", key);
        }
        /** bean定义类*/
        GenericBeanDefinition define = new GenericBeanDefinition();
        /** 设置bean的类型，此处DynamicRoutingDataSource是继承AbstractRoutingDataSource的实现类*/
        define.setBeanClass(RoutingDataSource.class);
        /** 需要注入的参数**/
        MutablePropertyValues mpv = define.getPropertyValues();
        /** 添加默认数据源，避免key不存在的情况没有数据源可用**/
        mpv.add("defaultTargetDataSource", defaultDatasource);
        /** 添加其他数据源**/
        mpv.add("targetDataSources", customDataSources);
        /** 将该bean注册为datasource，不使用springboot自动生成的datasource**/
        beanDefinitionRegistry.registerBeanDefinition("datasource", define);
        logger.info("注册数据源成功，一共注册{}个数据源", customDataSources.keySet().size() + 1);
    }

    /**通过字符串获取数据源class对象*/
    private Class<? extends DataSource> getDataSourceType(String typeStr) {
        Class<? extends DataSource> type;
        try {
            if (StringUtils.hasLength(typeStr)) {
                /**字符串不为空则通过反射获取class对象*/
                type = (Class<? extends DataSource>) Class.forName(typeStr);
            } else {
                /**默认为hikariCP数据源，与springboot默认数据源保持一致*/
                type = HikariDataSource.class;
            }
            return type;
        } catch (Exception e) {
            /**无法通过反射获取class对象的情况则抛出异常，该情况一般是写错了，所以此次抛出一个runtimeexception*/
            throw new IllegalArgumentException("can not resolve class with type: " + typeStr);
        }
    }

    /**绑定参数，以下三个方法都是参考DataSourceBuilder的bind方法实现的，目的是尽量保证我们自己添加的数据源构造过程与springboot保持一致*/
    private void bind(DataSource result, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        /**将参数绑定到对象*/
        binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
    }

    private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        /**通过类型绑定参数并获得实例对象*/
        return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
    }

    /**参数路径，对应配置文件中的值，如: spring.datasource*/
    private <T extends DataSource> T bind(Class<T> clazz, String sourcePath) {
        Map properties = binder.bind(sourcePath, Map.class).get();
        return bind(clazz, properties);
    }

    /**EnvironmentAware接口的实现方法，通过aware的方式注入，此处是environment对象*/
    @Override
    public void setEnvironment(Environment environment) {
        logger.info("开始注册数据源");
        this.evn = environment;
        /**绑定配置器*/
        binder = Binder.get(evn);
    }




}
